mxlpy 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

mxlpy/__init__.py

@@ -52,6 +52,7 @@ from . import (
     plot,
     report,
     sbml,
+    units,
 )
 from .integrators import DefaultIntegrator, Scipy
 from .label_map import LabelMapper
@@ -61,7 +62,7 @@ from .model import Model
 from .scan import steady_state, time_course, time_course_over_protocol
 from .simulator import Simulator
 from .symbolic import SymbolicModel, to_symbolic_model
-from .types import Derived, IntegratorProtocol, unwrap
+from .types import Derived, IntegratorProtocol, Parameter, Variable, unwrap
 
 with contextlib.suppress(ImportError):
     from .integrators import Assimulo
@@ -87,9 +88,11 @@ __all__ = [
     "LabelMapper",
     "LinearLabelMapper",
     "Model",
+    "Parameter",
     "Scipy",
     "Simulator",
     "SymbolicModel",
+    "Variable",
     "cartesian_product",
     "compare",
     "distributions",
@@ -110,6 +113,7 @@ __all__ = [
     "time_course",
     "time_course_over_protocol",
     "to_symbolic_model",
+    "units",
     "unwrap",
 ]
 

mxlpy/carousel.py

@@ -0,0 +1,166 @@
+"""Reaction carousel."""
+
+from __future__ import annotations
+
+import itertools as it
+from copy import deepcopy
+from dataclasses import dataclass, field
+from functools import partial
+from typing import TYPE_CHECKING
+
+import pandas as pd
+
+from mxlpy import parallel, scan
+
+__all__ = ["Carousel", "CarouselSteadyState", "CarouselTimeCourse", "ReactionTemplate"]
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    from mxlpy import Model
+    from mxlpy.types import Array, IntegratorType, RateFn
+
+
+@dataclass
+class ReactionTemplate:
+    """Template for a reaction in a model."""
+
+    fn: RateFn
+    args: list[str]
+    additional_parameters: dict[str, float] = field(default_factory=dict)
+
+
+@dataclass
+class CarouselSteadyState:
+    """Time course of a carousel simulation."""
+
+    carousel: list[Model]
+    results: list[scan.TimePoint]
+
+    def get_variables_by_model(self) -> pd.DataFrame:
+        """Get the variables of the time course results, indexed by model."""
+        return pd.DataFrame({i: r.variables for i, r in enumerate(self.results)}).T
+
+
+@dataclass
+class CarouselTimeCourse:
+    """Time course of a carousel simulation."""
+
+    carousel: list[Model]
+    results: list[scan.TimeCourse]
+
+    def get_variables_by_model(self) -> pd.DataFrame:
+        """Get the variables of the time course results, indexed by model."""
+        return pd.concat({i: r.variables for i, r in enumerate(self.results)})
+
+
+def _dict_product[T1, T2](d: Mapping[T1, Iterable[T2]]) -> Iterable[dict[T1, T2]]:
+    yield from (dict(zip(d.keys(), x, strict=True)) for x in it.product(*d.values()))
+
+
+def _make_reaction_carousel(
+    model: Model, rxns: dict[str, list[ReactionTemplate]]
+) -> Iterable[Model]:
+    for d in _dict_product(rxns):
+        new = deepcopy(model)
+        for rxn, template in d.items():
+            new.add_parameters(template.additional_parameters)
+            new.update_reaction(name=rxn, fn=template.fn, args=template.args)
+        yield new
+
+
+class Carousel:
+    """A carousel of models with different reaction templates."""
+
+    variants: list[Model]
+
+    def __init__(
+        self,
+        model: Model,
+        variants: dict[str, list[ReactionTemplate]],
+    ) -> None:
+        """Initialize the carousel with a model and reaction templates."""
+        self.variants = list(
+            _make_reaction_carousel(
+                model=model,
+                rxns=variants,
+            )
+        )
+
+    def time_course(
+        self,
+        time_points: Array,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+    ) -> CarouselTimeCourse:
+        """Simulate the carousel of models over a time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._time_course_worker,  # noqa: SLF001
+                    time_points=time_points,
+                    integrator=integrator,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselTimeCourse(
+            carousel=self.variants,
+            results=results,
+        )
+
+    def protocol_time_course(
+        self,
+        protocol: pd.DataFrame,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+    ) -> CarouselTimeCourse:
+        """Simulate the carousel of models over a protocol time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._protocol_worker,  # noqa: SLF001
+                    protocol=protocol,
+                    integrator=integrator,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselTimeCourse(
+            carousel=self.variants,
+            results=results,
+        )
+
+    def steady_state(
+        self,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+        rel_norm: bool = False,
+    ) -> CarouselSteadyState:
+        """Simulate the carousel of models over a time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._steady_state_worker,  # noqa: SLF001
+                    integrator=integrator,
+                    rel_norm=rel_norm,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselSteadyState(
+            carousel=self.variants,
+            results=results,
+        )

mxlpy/compare.py

@@ -230,11 +230,7 @@ def protocol_time_courses(
 ) -> ProtocolComparison:
     """Compare the time courses of two models."""
     return ProtocolComparison(
-        res1=unwrap(
-            Simulator(m1).simulate_over_protocol(protocol=protocol).get_result()
-        ),
-        res2=unwrap(
-            Simulator(m2).simulate_over_protocol(protocol=protocol).get_result()
-        ),
+        res1=unwrap(Simulator(m1).simulate_protocol(protocol=protocol).get_result()),
+        res2=unwrap(Simulator(m2).simulate_protocol(protocol=protocol).get_result()),
         protocol=protocol,
     )

mxlpy/experimental/diff.py

@@ -187,7 +187,7 @@ def model_diff(m1: Model, m2: Model) -> ModelDiff:
         if (v2 := m2._parameters.get(k)) is None:  # noqa: SLF001
             diff.missing_parameters.add(k)
         elif v1 != v2:
-            diff.different_parameters[k] = (v1, v2)
+            diff.different_parameters[k] = (v1, v2)  # type: ignore
 
     for k, v1 in m1._variables.items():  # noqa: SLF001
         if (v2 := m2._variables.get(k)) is None:  # noqa: SLF001